home *** CD-ROM | disk | FTP | other *** search
/ Nebula 2 / Nebula Two.iso / Apps / ScreenSavers / Sentinel / Source / ScreenLock.m < prev    next >
Encoding:
Text File  |  1995-06-12  |  5.5 KB  |  272 lines
  1.  
  2. /* Generated by Interface Builder */
  3.  
  4. #import <libc.h>
  5. #import <pwd.h>
  6. #import <time.h>
  7.  
  8. #import <appkit/publicWraps.h>
  9. #import <appkit/MenuCell.h>
  10. #import <appkit/Panel.h>
  11. #import <appkit/Application.h>
  12.  
  13. #import "LockMgr.h"
  14. #import "ScreenLock.h"
  15. #import "ScreenLockPS.h"
  16. #import "SignalMgr.h"
  17.  
  18. void fadeTimerProc ( DPSTimedEntry teNumber, double now, char *userData )
  19. {
  20.     [ (id) userData timer ] ;
  21.     return ;
  22. }
  23.  
  24.  
  25. @implementation ScreenLock
  26.  
  27. - init
  28. {
  29.     float            minX = 32767 ;
  30.     float            minY = 32767 ;
  31.     float            maxX = -32767 ;
  32.     float            maxY = -32767 ;
  33.     NXScreen    * screenList ;
  34.     int            screenCount ;
  35.  
  36.     [ super init ] ;
  37.     [ NXApp getScreens: &screenList count: &screenCount ] ;
  38.     while ( screenCount )
  39.     {
  40.         minX = MIN ( minX, screenList->screenBounds.origin.x ) ;
  41.         minY = MIN ( minY, screenList->screenBounds.origin.y ) ;
  42.         maxX = MAX ( maxX, screenList->screenBounds.origin.x +
  43.                 screenList->screenBounds.size.width ) ;
  44.         maxY = MAX ( maxY, screenList->screenBounds.origin.y +
  45.                 screenList->screenBounds.size.height ) ;
  46.         screenList++ ;
  47.         screenCount-- ;
  48.     }
  49.     
  50.     screenRect.origin.x = minX ;
  51.     screenRect.origin.y = minY ;
  52.     screenRect.size.width = maxX - minX ;
  53.     screenRect.size.height = maxY - minY ;
  54.     
  55.     [ [ SignalMgr new ] addObject: self ] ;
  56.     return self ;
  57. }
  58.  
  59.  
  60. - lock: sender
  61. {
  62.     struct tm            * theTime ;
  63.     time_t            lowLevelTime ;
  64.     char                subTitle [ 128 ] ;
  65.     char                userTitle [ 128 ] ;
  66.     struct passwd        * userInfo ;
  67.  
  68.     if ( isLocked )
  69.     {
  70.         return self ;
  71.     }
  72.  
  73.     if ( ! ( userInfo = getpwuid ( getuid ( ) ) ) )
  74.     {
  75.         NXRunAlertPanel ( "FAILED", "Can't get user information", 
  76.                 "OK", NULL, NULL ) ;
  77.         return self ;
  78.     }
  79.     lowLevelTime = time ( 0 ) ;
  80.     srandom ( lowLevelTime ) ;
  81.     theTime = localtime ( &lowLevelTime ) ;
  82.  
  83.     sprintf ( subTitle, "as of %d:%02d:%02d %cm",
  84.             theTime->tm_hour % 12 ? theTime->tm_hour % 12 : 12,
  85.             theTime->tm_min,
  86.             theTime->tm_sec,
  87.             theTime->tm_hour < 12 ? 'a' : 'p' ) ;
  88.     sprintf ( userTitle, "User %s logged in...", userInfo->pw_gecos ) ;
  89.     PSLockInit ( subTitle, userTitle,
  90.             [ lockMgr requirePassword ] ? "Enter password to unlock system" :
  91.             "Press a key to unlock system",
  92.             screenRect.origin.x, screenRect.origin.y,
  93.             screenRect.size.width, screenRect.size.height ) ;
  94.     passwordChars = 0 ;
  95.     [ NXApp activateSelf: YES ] ;
  96.     [ waitWindow makeKeyAndOrderFront: self ] ;
  97.     [ waitWindow makeFirstResponder: self ] ;
  98.     
  99.     PSWipeNotice ( ) ;
  100.     NXPing ( ) ;
  101.     origLevel = [ lockMgr brightness ] ;
  102.     [ lockMgr setBrightness: 1.0 ] ;
  103.     dimDelta = 0.0 ;
  104.     PSDrawNotice ( random ( ) % (int) ( screenRect.size.width - 600 ),
  105.             random ( ) % (int) ( screenRect.size.height - 80 ) ) ;
  106.  
  107.     timedEntry = DPSAddTimedEntry ( 5.0,
  108.             (DPSTimedEntryProc) fadeTimerProc, (void *) self,
  109.             NX_MODALRESPTHRESHOLD ) ;
  110.     [ quitOption setEnabled: NO ] ;
  111.     [ lockOption setEnabled: NO ] ;
  112.     [ hideOption setEnabled: NO ] ;
  113.     isLocked = YES ;
  114.     return self ;
  115. }
  116.  
  117.  
  118. - unlock: sender
  119. {
  120.     if ( ! isLocked )
  121.     {
  122.         return self ;
  123.     }
  124.  
  125.     DPSRemoveTimedEntry ( timedEntry ) ;
  126.     PSWipeNotice ( ) ;
  127.     NXPing ( ) ;
  128.     [ lockMgr setBrightness: origLevel ] ;
  129.     [ NXApp hide: self ] ;
  130.     [ waitWindow orderOut: self ] ;
  131.     PSLockEnd ( ) ;
  132.     [ quitOption setEnabled: YES ] ;
  133.     [ lockOption setEnabled: YES ] ;
  134.     [ hideOption setEnabled: YES ] ;
  135.     NXPing ( ) ;
  136.     isLocked = NO ;
  137.     return self ;
  138. }
  139.  
  140.  
  141. - (BOOL) isLocked
  142. {
  143.     return isLocked ;
  144. }
  145.  
  146.  
  147. - keyDown: (NXEvent *) theEvent
  148. {
  149.     char        theChar = theEvent->data.key.charCode ;
  150.  
  151.     if ( ! [ lockMgr requirePassword ] )
  152.     {
  153.         [ self unlock: self ] ;
  154.         return self ;
  155.     }
  156.     
  157.     switch ( theChar )
  158.     {
  159.         case 8:
  160.         case 127:
  161.         {
  162.             if ( passwordChars )
  163.             {
  164.                 passwordChars-- ;
  165.             } 
  166.             break ;
  167.         }
  168.         
  169.         case 13:
  170.         {
  171.             struct passwd        * userInfo ;
  172.             struct passwd        * sentinelUserInfo ;
  173.             char                * encoded ;
  174.  
  175.             password [ passwordChars ] = 0 ;
  176.  
  177.             userInfo = getpwuid ( getuid ( ) ) ;
  178.             if ( userInfo )
  179.             {
  180.                 encoded = crypt ( password, userInfo->pw_passwd ) ;
  181.                 if ( ! strcmp ( encoded, userInfo->pw_passwd ) )
  182.                 {
  183.                     [ self unlock: self ] ;
  184.                     return self ;
  185.                 }
  186.             }
  187.  
  188.             sentinelUserInfo = getpwnam ( "sentinel" ) ;
  189.             if ( sentinelUserInfo )
  190.             {
  191.                 encoded = crypt ( password, sentinelUserInfo->pw_passwd ) ;
  192.                 if ( ! strcmp ( encoded, sentinelUserInfo->pw_passwd ) )
  193.                 {
  194.                     [ self unlock: self ] ;
  195.                     return self ;
  196.                 }
  197.             }
  198.  
  199.             if ( ( ! userInfo ) && ( ! sentinelUserInfo ) )
  200.             {
  201.                 [ self unlock: self ] ;
  202.                 NXRunAlertPanel ( "FAILED", "Can't get user information",
  203.                         "OK", NULL, NULL ) ;
  204.                 return self ;
  205.             }
  206.  
  207.             NXBeep ( ) ;
  208.             passwordChars = 0 ;
  209.             break ;
  210.         }
  211.         
  212.         default:
  213.         {
  214.             if ( ( theChar >= 32 ) && ( passwordChars < 127 ) )
  215.             {
  216.                 password [ passwordChars++ ] = theChar ;
  217.             }
  218.             break ;
  219.         }
  220.     }
  221.     return self ;
  222. }
  223.  
  224.  
  225. - (BOOL) acceptsFirstResponder
  226. {
  227.     return YES ;
  228. }
  229.  
  230.  
  231. - timer
  232. {
  233.     if ( dimDelta == 0.0 )
  234.     {
  235.         [ NXApp activateSelf: YES ] ;
  236.         [ waitWindow makeKeyAndOrderFront: self ] ;
  237.         [ waitWindow makeFirstResponder: self ] ;
  238.         DPSRemoveTimedEntry ( timedEntry ) ;
  239.         timedEntry = DPSAddTimedEntry ( 0.01, (DPSTimedEntryProc)
  240.                 fadeTimerProc, (void *) self, NX_MODALRESPTHRESHOLD ) ;
  241.         dimDelta = -0.02 ;
  242.         lastLevel = 1.0 ;
  243.         return self ;
  244.     }
  245.     
  246.     lastLevel += dimDelta ;
  247.     [ lockMgr setBrightness: lastLevel ] ;
  248.     if ( lastLevel < 0.02 )
  249.     {
  250.         PSDrawNotice ( random ( ) % (int) ( screenRect.size.width - 600 ),
  251.                 random ( ) % (int) ( screenRect.size.height - 80 ) ) ;
  252.         dimDelta = 0.02 ;
  253.     }
  254.     if ( lastLevel > 0.98 )
  255.     {
  256.         dimDelta = 0.0 ;
  257.         DPSRemoveTimedEntry ( timedEntry ) ;
  258.         timedEntry = DPSAddTimedEntry ( 5.0, (DPSTimedEntryProc) fadeTimerProc,
  259.                 (void *) self, NX_MODALRESPTHRESHOLD ) ;
  260.     }
  261.     return self ;
  262. }
  263.  
  264.  
  265. - interrupt
  266. {
  267.     [ self unlock: self ] ;
  268.     return self ;
  269. }
  270.  
  271. @end
  272.